# -*- coding: utf-8 -*-
# author BaiYunpeng
# date 2021-03-30


import os
import re
import sys

def process_Lines(target_text,process_mode,find_mode,target_part='',new_part='',lineA=1,lineB=1):
    # 功能：以行处理文本,根据process_mode不同,删除、保留匹配行、替换行、删除某AB行之间的匹配行、统计匹配行数
    # 输入process_mode：
    #   1、删除匹配行 
    #   2、保留匹配行 
    #   3、替换匹配到的部分（不是行）
    #   4、统计匹配行数
    # 输入find_mode:
    #   0、全文查找
    #   1、从行A和行B之间查找
    # target_part: 查找目标行的模式,可以用正则表达式编写
    # new_part：替换后的新部分
    # lineA 如果输入find_mode是1,此值是范围开始行的数字（起始数字是1）
    # lineB 如果输入find_mode是1,此值是范围尾行的数字（起始数字是1）
    
    # 拿原文内容
    f=open(target_text,'r')
    alllines=f.readlines()
    f.close()
    
    # 处理过程
    if process_mode == 1: #删除匹配行
        f=open(target_text,'w+')
        if find_mode == 0: #全局
            for eachline in alllines:
                if not re.search(target_part,eachline):
                    f.writelines(eachline)
        elif find_mode == 1: #部分
            for index,eachline in enumerate(alllines):
                if lineA-1 <= index <= lineB-1:
                    if not re.search(target_part,eachline):
                        f.writelines(eachline)
                else:
                    f.writelines(eachline)
        else:
            sys.exit('1find_mode input error')
        f.close()
    elif process_mode == 2: #保留匹配行
        f=open(target_text,'w+')
        if find_mode == 0: #全局
            for eachline in alllines:
                if re.search(target_part,eachline):
                    f.writelines(eachline)
        elif find_mode == 1: #部分
            for index,eachline in enumerate(alllines):
                if lineA-1 <= index <= lineB-1:
                    if re.search(target_part,eachline):
                        f.writelines(eachline)
                else:
                    f.writelines(eachline)
        else:
            sys.exit('2find_mode input error')
        f.close()
    elif process_mode == 3: #替换为新行
        f=open(target_text,'w+')
        if find_mode == 0: #全局
            for eachline in alllines:
                a=re.sub(target_part,new_part,eachline)
                f.writelines(a)
        elif find_mode == 1: #部分
            for index,eachline in enumerate(alllines):
                if lineA-1 <= index <= lineB-1:
                    a=re.sub(target_part,new_part,eachline)
                    f.writelines(a)
                else:
                    f.writelines(eachline)
        else:
            sys.exit('3find_mode input error')
        f.close()
    elif process_mode == 4: #统计匹配行数
        mark = 0
        if find_mode == 0: #全局
            for eachline in alllines:
                if re.search(target_part,eachline):
                    mark += 1
        elif find_mode == 1: #部分
            for index,eachline in enumerate(alllines):
                if lineA-1 <= index <= lineB-1:
                    if re.search(target_part,eachline):
                        mark += 1
                else:
                    pass
        else:
            sys.exit('4find_mode input error')
        return mark
    else:
        sys.exit('process_mode input error')

def process_HeadLines(target_text,mode,last_line_key='',new_head=[],prefer=0):
    # 功能：以行处理文本,根据process_mode不同,删除、保留头部、替换头部为新头部、直接添加新头、统计头部行数
    # 输入mode：
    #   1、删除头部 
    #   2、保留头部 
    #   3、替换头部为新头部
    #   4、直接添加新头
    #   5、统计头部行数
    # last_line_key: 查找头部最后一行的模式,可用正则表达式编写
    # new_head：如果mode是3或者4,替换的新头,格式是list,每一个元素是一行字符串,如果有换行,记得加换行符\n
    # prefer 若0表示用初次找到目标行来定位,若1表示用最后找到的目标行来定位
    
    # 拿原文内容
    f=open(target_text,'r')
    alllines=f.readlines()
    f.close()
    
    # 找到头部的最后一行
    if mode != 4:
        
        # 找到尾行集合
        find_pool = []
        for index,line in enumerate(alllines):
            if re.search(last_line_key,line):
                find_pool.append(index)
        if len(find_pool) == 0:
            sys.exit('there is no this head part')
        
        # 根据偏向,选择使用的尾行定位
        if prefer == 0:
            head_line_index = find_pool[0]
        elif prefer == 1:
            head_line_index = find_pool[-1]
        else:
            sys.exit("prefer input error")
        
        # 处理过程
        mark = 0
        if mode == 1: #删除头部
            f=open(target_text,'w+')
            f.writelines(alllines[head_line_index+1:])
            f.close()
        elif mode == 2: #保留头部
            f=open(target_text,'w+')
            f.writelines(alllines[:head_line_index+1])
            f.close()
        elif mode == 3: #替换头部
            f=open(target_text,'w+')
            new_contexts = new_head + alllines[head_line_index+1:]
            f.writelines(new_contexts)
            f.close()
        elif mode == 5: #统计头部行数
            return head_line_index+1
    else:
        f=open(target_text,'w+')
        new_contexts = new_head + alllines
        f.writelines(new_contexts)
        f.close()

def process_TailLines(target_text,mode,first_line_key='',new_tail=[],prefer=0):
    # 功能：以行处理文本,根据mode不同,删除、保留尾巴、替换尾巴为新尾巴、直接添加新尾巴、统计尾巴行数
    # 输入mode：
    #   1、删除尾巴 
    #   2、保留尾巴 
    #   3、替换尾巴为新尾巴 new_tail
    #   4、直接添加新尾巴 new_tail
    #   5、统计尾巴行数
    # first_line_key: 查找尾巴第一行的模式,可用正则表达式编写
    # new_tail：如果mode是3或者4,替换的新尾巴,格式是list,每一个元素是一行字符串,如果有换行,记得加换行符\n
    # prefer 若0表示用初次找到目标行来定位,若1表示用最后找到的目标行来定位
    
    # 拿原文内容
    f=open(target_text,'r')
    alllines=f.readlines()
    f.close()
    
    all_len = len(alllines)
    
    #find first line in tail
    if mode != 4:
        
        # 根据偏向,确定行定位
        find_pool = []
        for index,line in enumerate(alllines):
            if re.search(first_line_key,line):
                find_pool.append(index)
        if prefer == 0:
            tail_line_index = find_pool[0]
        elif prefer == 1:
            tail_line_index = find_pool[-1]
        else:
            sys.exit("prefer value is not usable")
        
        # print(tail_line_index)
        # 处理过程
        mark = 0
        if mode == 1: #删除尾巴
            f=open(target_text,'w+')
            f.writelines(alllines[:tail_line_index])
            f.close()
        elif mode == 2: #保留尾巴
            f=open(target_text,'w+')
            f.writelines(alllines[tail_line_index:])
            f.close()
        elif mode == 3: #替换尾巴
            f=open(target_text,'w+')
            new_contexts = alllines[:tail_line_index] + new_tail
            f.writelines(new_contexts)
            f.close()
        elif mode == 5: #统计尾巴行数
            return all_len - tail_line_index
    else:
        f=open(target_text,'w+')
        new_contexts = alllines + new_tail
        f.writelines(new_contexts)
        f.close()

def process_PartLines(target_text,mode,first_line_key='',last_line_key='',new_midpart=[],first_prefer=0,last_prefer=1):
    # 功能：以行处理文本,根据mode不同,删除、保留中间部分、替换中间部分为新中间部分、统计中间部分的行数
    # 输入mode：
    #   1、删除中间部分 
    #   2、保留中间部分 
    #   3、替换中间部分为新中间部分 new_midpart
    #   4、统计中间部分行数
    # first_line_key: 查找中间部分的第一行的模式,可用正则表达式编写
    # last_line_key: 查找中间部分的最后一行的模式,可用正则表达式编写
    # new_midpart：如果mode是3,替换的新中间部分,格式是list,每一个元素是一行字符串,如果有换行,记得加换行符\n
    # first_prefer和last_prefer 若0表示用初次找到目标行来定位,若1表示用最后找到的目标行来定位
    
    # 拿原文内容
    f=open(target_text,'r')
    alllines=f.readlines()
    f.close()
    
    all_len = len(alllines)
    #find first line in midpart
    firstline_pool = []
    lastline_pool = []
    
    for index,line in enumerate(alllines):
        if re.search(first_line_key,line):
            firstline_pool.append(index)
        if re.search(last_line_key,line):
            lastline_pool.append(index)
    
    # if len(firstline_pool) == 0:
        # sys.exit("Can't find First Line in midpart")
    # if len(lastline_pool) == 0:
        # sys.exit("Can't find Last Line in midpart")
    
    
    # 根据偏向,选择行的定位
    if first_prefer == 0:
        midpart_firstline_index = firstline_pool[0]
    elif first_prefer == 1:
        midpart_firstline_index = firstline_pool[-1]
    else:
        sys.exit("first_prefer value is not usable")
    
    if last_prefer == 0:
        midpart_lastline_index = lastline_pool[0]
    elif last_prefer == 1:
        midpart_lastline_index = lastline_pool[-1]
    else:
        sys.exit("last_prefer value is not usable")
    
    # print(midpart_line_index)
    # 处理过程
    mark = 0
    if mode == 1: #删除中间部分
        f=open(target_text,'w+')
        f.writelines(alllines[:midpart_firstline_index]+alllines[midpart_lastline_index+1:])
        f.close()
    elif mode == 2: #保留中间部分
        f=open(target_text,'w+')
        f.writelines(alllines[midpart_firstline_index:midpart_lastline_index+1])
        f.close()
    elif mode == 3: #替换中间部分
        f=open(target_text,'w+')
        new_contexts = alllines[:midpart_firstline_index] + new_midpart + alllines[midpart_lastline_index+1:]
        f.writelines(new_contexts)
        f.close()
    elif mode == 4: #统计中间部分行数
        return midpart_lastline_index - midpart_firstline_index + 1

def insert_multi_lines(target_text,line_number,new_lines=[]):
    # 功能：以行处理文本,根据输入数字line_number ,找到一行,在该行之后插入多行
    # line_number: 目标的行数，从1开始数
    # new_lines: 插入的新的多行,格式是list,每个元素是一行字符串,如果有换行,记得加换行符\n
    
    # 拿原文内容
    f=open(target_text,'r')
    alllines=f.readlines()
    f.close()
    
    f=open(target_text,'w+')
    new_contexts = alllines[:line_number] + new_lines + alllines[line_number:]
    f.writelines(new_contexts)
    f.close()
    
def process_several_lines(target_text,target_set,mode,new_line=''):
    # 功能：以行处理文本,索引target_set,找到一组行,删除\留下\替换目标行
    # target_set: 行数的集合（以1开头）
    # 输入mode：
    #   1、删除目标行 
    #   2、保留目标行 
    #   3、替换目标行为新的同一行 new_line
    # new_line: 当mode是3时,替换的新行,如果有换行,记得加换行符\n
    
    # 拿原文内容
    f=open(target_text,'r')
    alllines=f.readlines()
    f.close()
    
    if mode == 1: # 删除目标行
        for i in sorted(target_set, reverse=True):
            del alllines[i-1]
        f=open(target_text,'w+')
        f.writelines(alllines)
        f.close()
    elif mode == 2: # 保留目标行
        out = []
        target_set = sorted(target_set)
        for i in target_set:
            index = i-1
            out.append(alllines[index])
        f=open(target_text,'w+')
        f.writelines(out)
        f.close()
    elif mode == 3:
        for i in target_set:
            index = i-1
            alllines[index]=new_line
        f=open(target_text,'w+')
        f.writelines(alllines)
        f.close()

def delete_blank(target_text,mode,target_number=0,target_line='',prefer=0):
    # 功能：以行处理文本,删除空白行,根据mode全局删除或者部分删除
    # target_set: 行数的集合（以1开头）
    # 输入mode：
    #   1、全局删除空白行 
    #   2、某数字行，之后，删除空白行
    #   3、某数字行，之前，删除空白行
    #   4、查找某行，之后删除空白行
    #   5、查找某行，之前删除空白行
    
    # 拿原文内容
    f=open(target_text,'r')
    alllines=f.readlines()
    f.close()
    
    # 分情况删除空白行
    f = open(target_text, 'w+')
    if mode == 1:
        for line in alllines:
            if line.split():
                f.writelines(line)
    elif mode == 2:
        for index,line in enumerate(alllines):
            if index >= target_number-1:
                if line.split():
                    f.writelines(line)
            else:
                f.writelines(line)
    elif mode == 3:
        for index,line in enumerate(alllines):
            if index <= target_number-1:
                if line.split():
                    f.writelines(line)
            else:
                f.writelines(line)
    else:
        # 根据偏向,确定行定位
        find_pool = []
        for index,line in enumerate(alllines):
            if re.search(target_line,line):
                find_pool.append(index)
        if prefer == 0:
            target_line_index = find_pool[0]
        elif prefer == 1:
            target_line_index = find_pool[-1]
        else:
            sys.exit("prefer value is not usable")
        
        if mode == 4:
            for index,line in enumerate(alllines):
                if index >= target_line_index-1:
                    if line.split():
                        f.writelines(line)
                else:
                    f.writelines(line)
        elif mode == 5:
            for index,line in enumerate(alllines):
                if index <= target_line_index-1:
                    if line.split():
                        f.writelines(line)
                else:
                    f.writelines(line)
    f.close()

def check_word(target_text,word,mode,delete_linefeed=0,newword=''):
    # 功能：对文件以一大段的方式处理,以连续字符word查找目标,根据mode处理找到的word
    # word: 匹配的目标，可以是正则表达式
    # 输入mode：
    #   1、删除目标字符串 
    #   2、替换目标字符串为 newword 
    #   3、统计目标字符串出现的次数
    # delete_linefeed 是0表示,如果替换的原始字符串包含多个换行,则删除的时候会同步删除多个换行,如果是1表示,删除的时候保留换行符（仅在删除mode1生效）
    # newword: 当mode是2时,替换的新字符串,如果有换行,记得加换行符\n
    
    f = open(target_text, 'r')
    allcontents = f.read()
    f.close()
    
    if mode == 1:
        f = open(target_text, 'w')
        newword = ''
        if delete_linefeed == 0:
            newword = ''
        elif delete_linefeed == 1:
            cr_n = word.count(r'\r')
            lr_n = word.count(r'\n')
            max(cr_n,lr_n)
            newword = r'\n' * max(cr_n,lr_n)
        kk=re.sub(word,newword,allcontents)
        f.write(kk)
        f.close()
    elif mode == 2:
        f = open(target_text, 'w')
        # kk = allcontents.replace(word,newword)
        kk=re.sub(word,newword,allcontents)
        f.write(kk)
        f.close()
    elif mode ==3:
        k = re.findall(word,allcontents)
        if k:
            klen = len(k)
        else:
            klen = 0
        return klen
    
def main():
    
    files = os.listdir('inbox')
    allnum = len(files)
    for indexx,file in enumerate(files):
        print(indexx,allnum)
        file_path = os.path.join('inbox',file)
        
        # process_Lines(file_path,3,0,r'^Time taken: \d+ ms ','GGGGGGGGGGGGGGGG') #删除行
        process_Lines(file_path,3,0,r'D:/CODE','KKKKK') #删除行
        

if __name__ == '__main__':
    main()




